package com.example.edu.Utils;
import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.databind.JsonNode;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static com.example.edu.Utils.RegexPatterns.*;

public class RegexUtils {
    /**
     * 是否是无效手机格式
     * @param phone 要校验的手机号
     * @return true:符合，false：不符合
     */
    public static boolean isPhoneInvalid(String phone){
        return mismatch(phone, RegexPatterns.PHONE_REGEX);
    }
    /**
     * 是否是无效邮箱格式
     * @param email 要校验的邮箱
     * @return true:符合，false：不符合
     */
    public static boolean isEmailInvalid(String email){
        return mismatch(email, RegexPatterns.EMAIL_REGEX);
    }

    /**
     * 是否是无效验证码格式
     * @param code 要校验的验证码
     * @return true:符合，false：不符合
     */
    public static boolean isCodeInvalid(String code){
        return mismatch(code, RegexPatterns.VERIFY_CODE_REGEX);
    }

    // 校验是否不符合正则格式
    private static boolean mismatch(String str, String regex){
        if (StrUtil.isBlank(str)) {
            return true;
        }
        return !str.matches(regex);
    }

    public static int getPictureId(String url){
        // 创建 Pattern 和 Matcher 对象
        Pattern pattern = Pattern.compile(PICTURE_URL_REGEX);
        Matcher matcher = pattern.matcher(url);

        // 如果匹配成功，则提取 picture_id 并转换为 int
        if (matcher.find()) {
            String pictureIdStr = matcher.group(1);  // 提取 picture_id 部分
            try {
                return Integer.parseInt(pictureIdStr);  // 将字符串转换为 int 并返回
            } catch (NumberFormatException e) {
                System.out.println("Invalid picture_id format");
            }
        }

        // 如果未匹配到 picture_id 或解析失败，返回 -1 表示错误
        return -1;
    }

    // 按数字标题切分文档内容
    public static List<String> splitByTitles(String documentContent) {
        List<String> sections = new ArrayList<>();

        // 正则表达式匹配标题（以数字+点开头）
        Pattern pattern = Pattern.compile(DOCUMENT_CUT_REGEX2);
        Matcher matcher = pattern.matcher(documentContent);

        // 查找所有标题的位置
        List<Integer> positions = new ArrayList<>();
        while (matcher.find()) {
            positions.add(matcher.start());
        }

        // 如果没有找到任何标题，直接返回
        if (positions.isEmpty()) {
            sections.add(documentContent);
            return sections;
        }

        // 将文档内容按标题切分
        for (int i = 0; i < positions.size(); i++) {
            int end = i < positions.size() - 1 ? positions.get(i + 1) : documentContent.length();
            String section = documentContent.substring(positions.get(i), end).trim();
            sections.add(section);
        }

        return sections;
    }

    // 按windows双换行符切分
    public static List<String> splitByParagraphs(String documentContent) {
        return Arrays.asList(documentContent.split(DOCUMENT_CUT_REGEX));
    }

    // 按固定数目字符切分文本
    public static List<String> splitTextIntoChunks(String text) {
        List<String> chunks = new ArrayList<>();
        for (int i = 0; i < text.length(); i += CHUNK_SIZE) {
            chunks.add(text.substring(i, Math.min(i + CHUNK_SIZE, text.length())));
        }
        return chunks;
    }

    // 按JSON格式切分文本
    public static List<String> extractTextSlices(JsonNode children) {
        List<String> slices = new ArrayList<>();
        String head = null;
        StringBuilder currentSlice = new StringBuilder();
        for (JsonNode node : children) {
            if ("heading".equals(node.get("type").asText())) {
                // 遇到 heading 结束当前切片
                if (currentSlice.length() > 0) {
                    slices.add(currentSlice.toString());
                    currentSlice.setLength(0);
                }
                head = node.get("children").get(0).get("text").asText();
                continue;
            }
            else
                currentSlice.append(head != null ? head+"\n" : "");
            JsonNode subChildren = node.get("children");
            extractNode(subChildren,currentSlice);
        }
        // 添加最后一个切片
        if (currentSlice.length() > 0) {
            slices.add(currentSlice.toString());
        }
        return slices;
    }

    public static String extractText(JsonNode children){
        StringBuilder text = new StringBuilder();
        extractNode(children,text);
        return text.toString();
    }

    private static void extractNode(JsonNode children,StringBuilder text){
        if (children != null && children.isArray()){
            for(JsonNode child : children) {
                if(child.has("text"))
                    text.append(child.get("text").asText()).append("\n");
                if(child.has("children"))
                    extractNode(child.get("children"),text);
            }
        }
    }
}
